package permission

import (
	models "HeadLineNews/proto_models/manage/permission_model"
	"HeadLineNews/resp"
	"github.com/gin-gonic/gin"
)

type Server interface {
	AddGroupHandler(c *gin.Context)
	DeleteGroupHandler(c *gin.Context)
	ListGroupHandler(c *gin.Context)
	ListPermsHandler(c *gin.Context)

	AddPermsToGroupHandler(c *gin.Context)
	UpdatePermsToGroupHandler(c *gin.Context)
	ListGroupPermsHandler(c *gin.Context)

	AddAdminsToGroupHandler(c *gin.Context)
	UpdateAdminsToGroupHandler(c *gin.Context)
	ListGroupAdminsHandler(c *gin.Context)

	FlushPermsHandler(c *gin.Context)
}

type server struct {
	repo Repo
	ctx  Ctx
}

func NewServer() Server {
	return &server{
		repo: NewRepo(),
		ctx:  NewCtx(),
	}
}

// AddGroupHandler 新增群组路由
func (s *server) AddGroupHandler(c *gin.Context) {
	p, err := s.ctx.ParseParamAddGroup(c)
	if err != nil {
		return
	}
	if err = s.repo.CheckUniqueGroup(c, p.GroupName); err != nil {
		return
	}
	if err = s.repo.InsertGroup(c, p); err != nil {
		return
	}
	resp.Success(c, nil)
}

// DeleteGroupHandler 根据id删除群组
func (s *server) DeleteGroupHandler(c *gin.Context) {
	if err := s.repo.DeleteGroup(c); err != nil {
		return
	}
	resp.Success(c, nil)
}

// ListGroupHandler 批量展示群组
func (s *server) ListGroupHandler(c *gin.Context) {
	p, err := s.ctx.ParseParamListGroup(c)
	if err != nil {
		return
	}
	var data *models.ResponseListGroup
	if data, err = s.repo.ListGroup(c, p); err != nil {
		return
	}
	resp.Success(c, data)
}

// ListPermsHandler 批量展示权限
func (s *server) ListPermsHandler(c *gin.Context) {
	p, err := s.ctx.ParseParamListPerms(c)
	if err != nil {
		return
	}
	var data *models.ResponseListPerms
	if data, err = s.repo.ListPerms(c, p); err != nil {
		return
	}
	resp.Success(c, data)
}

// AddPermsToGroupHandler 将权限保存到群组
func (s *server) AddPermsToGroupHandler(c *gin.Context) {
	p, err := s.ctx.ParseParamAddPermToGroup(c)
	if err != nil {
		return
	}
	if err = s.repo.CheckGroupExists(c, p.GroupId); err != nil {
		return
	}
	if err = s.repo.CheckPermsExist(c, p.UrlIds...); err != nil {
		return
	}
	if err = s.repo.CheckPermHasInGroup(c, p); err != nil {
		return
	}
	if err = s.repo.InsertPermsToGroup(c, p); err != nil {
		return
	}
	resp.Success(c, nil)
}

// UpdatePermsToGroupHandler 更新群组权限
func (s *server) UpdatePermsToGroupHandler(c *gin.Context) {
	p, err := s.ctx.ParseParamUpdatePermToGroup(c)
	if err != nil {
		return
	}
	if err = s.repo.CheckGroupExists(c, p.GroupId); err != nil {
		return
	}
	if err = s.repo.CheckPermsExist(c, p.UrlIds...); err != nil {
		return
	}
	if err = s.repo.UpdatePermsToGroup(c, p); err != nil {
		return
	}
	resp.Success(c, nil)
}

// ListGroupPermsHandler 展示群组有哪些权限
func (s *server) ListGroupPermsHandler(c *gin.Context) {
	p, err := s.ctx.ParseParamListGroupPerms(c)
	if err != nil {
		return
	}
	var data *models.ResponseGroupPerms
	if data, err = s.repo.ListGroupPerms(c, p); err != nil {
		return
	}
	resp.Success(c, data)
}

// AddAdminsToGroupHandler 将管理员保存到群组
func (s *server) AddAdminsToGroupHandler(c *gin.Context) {
	p, err := s.ctx.ParseParamAddAdminToGroup(c)
	if err != nil {
		return
	}
	if err = s.repo.CheckGroupExists(c, p.GroupId); err != nil {
		return
	}
	if err = s.repo.CheckAdminsExist(c, p.AdminIds...); err != nil {
		return
	}
	if err = s.repo.CheckAdminHasInGroup(c, p); err != nil {
		return
	}
	if err = s.repo.InsertAdminsToGroup(c, p); err != nil {
		return
	}
	resp.Success(c, nil)
}

// UpdateAdminsToGroupHandler 更新群组管理员
func (s *server) UpdateAdminsToGroupHandler(c *gin.Context) {
	p, err := s.ctx.ParseParamUpdateAdminToGroup(c)
	if err != nil {
		return
	}
	if err = s.repo.CheckGroupExists(c, p.GroupId); err != nil {
		return
	}
	if err = s.repo.CheckAdminsExist(c, p.AdminIds...); err != nil {
		return
	}
	if err = s.repo.UpdateAdminsToGroup(c, p); err != nil {
		return
	}
	resp.Success(c, nil)
}

// ListGroupAdminsHandler 展示群组有哪些管理员
func (s *server) ListGroupAdminsHandler(c *gin.Context) {
	p, err := s.ctx.ParseParamListGroupAdmins(c)
	if err != nil {
		return
	}
	var data *models.ResponseGroupAdmins
	if data, err = s.repo.ListGroupAdmins(c, p); err != nil {
		return
	}
	resp.Success(c, data)
}

// FlushPermsHandler 将权限刷新进 redis
func (s *server) FlushPermsHandler(c *gin.Context) {
	if err := s.repo.FlushGroupPerms(c); err != nil {
		return
	}
	resp.Success(c, nil)
}
